Empty Command Handling by Daniel Stelzer

"Adds a new hook into the parser, to edit a blank command before analyzing it."

Error

Includes and Included by are omitted for modules with errors

ni



You wrote 'Include (- [ Keyboard a_buffer a_table nw [...] continue; }
return nw; } ]; -) instead of "Reading the Command" in "Parser.i6t"' (Daniel Stelzer/Empty Command Handling.i7x, line 9):
but this syntax was withdrawn in April 2022, in favour of a more finely
controlled inclusion command. See the manual, but you can probably get what
you want using 'replacing "SomeFunctionName".' rather than 'instead of
...'.
Copy Include Empty Command Handling by Daniel Stelzer to clipboard Include Empty Command Handling by Daniel Stelzer.
This extension adds a new activity, "repairing an empty command". When the player presses ENTER at the prompt, without typing anything, the "repairing an empty command" activity will be run before showing the parser error. This can be used to give better responses to empty input without hacking into the response system.
For instance:
Rule for repairing an empty command: change the text of the player's command to "look".
This happens early enough in parsing that even special commands like "undo" and "oops", or a sequence of commands separated by periods, can be inserted.
Empty Command Handling by Daniel Stelzer begins here.
"Adds a new hook into the parser, to edit a blank command before analyzing it."
"based on code by Matt Weiner"
Repairing an empty command is an activity.
Include
 (-
[ Keyboard a_buffer a_table nw i w w2 x1 x2;
    sline1 = score; sline2 = turns;
   while (true) {
      ! Save the start of the buffer, in case "oops" needs to restore it
      for (i=0 : i<64 : i++) oops_workspace->i = a_buffer->i;
   
     ! In case of an array entry corruption that shouldn't happen, but would be
      ! disastrous if it did:
      #Ifdef TARGET_ZCODE;
      a_buffer->0 = INPUT_BUFFER_LEN;
      a_table->0 = 15; ! Allow to split input into this many words
      #Endif; ! TARGET_
   
     ! Print the prompt, and read in the words and dictionary addresses
      PrintPrompt();
      DrawStatusLine();
      KeyboardPrimitive(a_buffer, a_table);
   
     ! Set nw to the number of words
      #Ifdef TARGET_ZCODE; nw = a_table->1; #Ifnot; nw = a_table-->0; #Endif;
   
     ! If the line was blank, ask the game to fill it in. If it doesn't, print an error and get a fresh line. (CUSTOM)
      if (nw == 0) {
        x2 = false; ! Repurposing local variable as a flag
       
       BeginActivity( (+ repairing an empty command +) );
        if(ForActivity( (+ repairing an empty command +) ) == false){
       
         @push etype; etype = BLANKLINE_PE;
          players_command = 100;
         
         BeginActivity(PRINTING_A_PARSER_ERROR_ACT);
          if (ForActivity(PRINTING_A_PARSER_ERROR_ACT) == false) {
            PARSER_ERROR_INTERNAL_RM('X', noun); new_line;
          }
          EndActivity(PRINTING_A_PARSER_ERROR_ACT);
          @pull etype;
         
         x2 = true;
       
       }
        EndActivity( (+ repairing an empty command +) );
       
       if(x2) continue; ! If nothing happened, continue
      } ! (END CUSTOM)
     
     ! Unless the opening word was OOPS, return
      ! Conveniently, a_table-->1 is the first word on both the Z-machine and Glulx
   
     w = a_table-->1;
      if (w == OOPS1__WD or OOPS2__WD or OOPS3__WD) {
        if (oops_from == 0) { PARSER_COMMAND_INTERNAL_RM('A'); new_line; continue; }
        if (nw == 1) { PARSER_COMMAND_INTERNAL_RM('B'); new_line; continue; }
        if (nw > 2) { PARSER_COMMAND_INTERNAL_RM('C'); new_line; continue; }
     
       ! So now we know: there was a previous mistake, and the player has
        ! attempted to correct a single word of it.
     
       for (i=0 : i<INPUT_BUFFER_LEN : i++) buffer2->i = a_buffer->i;
        #Ifdef TARGET_ZCODE;
        x1 = a_table->9; ! Start of word following "oops"
        x2 = a_table->8; ! Length of word following "oops"
        #Ifnot; ! TARGET_GLULX
        x1 = a_table-->6; ! Start of word following "oops"
        x2 = a_table-->5; ! Length of word following "oops"
        #Endif; ! TARGET_
     
       ! Repair the buffer to the text that was in it before the "oops"
        ! was typed:
        for (i=0 : i<64 : i++) a_buffer->i = oops_workspace->i;
        VM_Tokenise(a_buffer,a_table);
     
       ! Work out the position in the buffer of the word to be corrected:
        #Ifdef TARGET_ZCODE;
        w = a_table->(4*oops_from + 1); ! Start of word to go
        w2 = a_table->(4*oops_from); ! Length of word to go
        #Ifnot; ! TARGET_GLULX
        w = a_table-->(3*oops_from); ! Start of word to go
        w2 = a_table-->(3*oops_from - 1); ! Length of word to go
        #Endif; ! TARGET_
     
       ! Write spaces over the word to be corrected:
        for (i=0 : i<w2 : i++) a_buffer->(i+w) = ' ';
     
       if (w2 < x2) {
          ! If the replacement is longer than the original, move up...
          for (i=INPUT_BUFFER_LEN-1 : i>=w+x2 : i-- )
            a_buffer->i = a_buffer->(i-x2+w2);
     
         ! ...increasing buffer size accordingly.
          #Ifdef TARGET_ZCODE;
          a_buffer->1 = (a_buffer->1) + (x2-w2);
          #Ifnot; ! TARGET_GLULX
          a_buffer-->0 = (a_buffer-->0) + (x2-w2);
          #Endif; ! TARGET_
        }
     
       ! Write the correction in:
        for (i=0 : i<x2 : i++) a_buffer->(i+w) = buffer2->(i+x1);
     
       VM_Tokenise(a_buffer, a_table);
        #Ifdef TARGET_ZCODE; nw = a_table->1; #Ifnot; nw = a_table-->0; #Endif;
     
       return nw;
      }
     ! Undo handling
   
     if ((w == UNDO1__WD or UNDO2__WD or UNDO3__WD) && (nw==1)) {
        Perform_Undo();
        continue;
      }
      i = VM_Save_Undo();
      #ifdef PREVENT_UNDO; undo_flag = 0; #endif;
      #ifndef PREVENT_UNDO; undo_flag = 2; #endif;
      if (i == -1) undo_flag = 0;
      if (i == 0) undo_flag = 1;
      if (i == 2) {
        VM_RestoreWindowColours();
        VM_Style(SUBHEADER_VMSTY);
        SL_Location(); print "^";
        ! print (name) location, "^";
        VM_Style(NORMAL_VMSTY);
        IMMEDIATELY_UNDO_RM('E'); new_line;
        continue;
      }
      return nw;
    }
 ];
-) instead of "Reading the Command" in "Parser.i6t".
Empty Command Handling ends here.